Post initial microcode load co-simulation method, system, and program product

ABSTRACT

Disclosed is simulation of circuit behavior by running a central electronic core simulation in a high level simulator up to and including initial microload, creation of a post-IML (initial microcode load) state, and transferring the post-initial microcode state from the central electronic core simulation to the post-initial microcode load co-simulator.

BACKGROUND OF THE INVENTION

1. Field of the Invention

The invention relates to the creation of a post-IML (initial microcode load) environment.

2. Description of Background

During the early “bring-up” of any server, any inherent design instabilities are compounded by time to market pressures, and fabrication difficulties. Integrating all of the components (hardware, microcode, and firmware) earlier, e.g. during “pre-bringup” would allow the “bringup” in the laboratory to progress faster. As used herein “bringup” is the initial testing of code and hardware, for example, prototype hardware and code.

The problem is that it is very difficult to get a Post IML state with all of the chip models and code. Hardware simulation accelerators could be used to execute IML and then pre-verify the functions. But this would take 160 hours minimum to just run IML on a hyper accelerator. As used herein “IML”, that is “Initial Microcode Load” is a process used in servers, such as the IBM zSeries servers, to initialize the hardware, load the firmware, and enable the server for customer use. Also solutions available are to unit test these code paths, however when unit simulation pieces are brought together for the first time in the laboratory, progress is hampered by relatively simple interface problems. This is due to specification anomalies, miscommunication, etc.

These problems illustrate the need for a Post IML Co-Simulation environment that encompasses all of the central electronic core (“CEC”) code and hardware models necessary to run a small server, for example, an IBM zSeries eServer.

SUMMARY OF INVENTION

The invention described herein overcomes these problems by starting from a software simulator using hardware description language constructs, such as IBM CECSIM, to generate a post-IML “processor state” complete checkpoint, which is then superimposed on the post-IML co-simulator. This allows simulation of circuit behavior by running a central electronic core simulation in a high level simulator, up to and including initial microload, creation of a post-IML (initial microcode load) state, and transferring the post-initial microcode state from the central electronic core simulation to the post-initial microcode load co-simulator. The resulting post-IML complete hardware co-simulation model is used for running test cases to verify functions, where the functions are characterized with a high degree of hardware and software interactions:

The Post-IML co-simulator allows pre-verification of Post-IML activities that would normally be executed for the first time in a “bring-up” laboratory environment. This extended capability results in further reduction in early hardware development costs.

Because of the relatively slow speed of hardware simulation accelerators, the co-simulators remove the time taken to go through a complete IML.

BRIEF DESCRIPTION OF THE DRAWINGS

The subject matter, which is regarded as the invention, is particularly pointed out and distinctly claimed in the claims at the conclusion of the specification. The foregoing and other objects, features, and advantages of the invention are apparent from the following detailed description taken in conjunction with the accompanying drawings in which:

FIG. 1 illustrates a flow chart of an example of the invention.

FIG. 2 illustrates the time and data movement processes of the flow chart of FIG. 1.

The detailed description explains the preferred embodiments of the invention, together with advantages and features, by way of example with reference to the drawings.

DETAILED DESCRIPTION OF THE INVENTION

The method, system, and program product described herein start from a software simulator. The simulator, such as IBM CECSIM, uses hardware description language constructs, to generate a post-IML “processor state” as a complete checkpoint. This post-IML “processor state” is then superimposed on a post-IML co-simulator. The resulting post-IML complete hardware co-simulator model is used for running test cases to verify functions, where the functions are characterized with a high degree of hardware and software interactions:

FIG. 1 illustrates four steps to synchronize the simulator and the post-IML environments:

-   1) Run the initial microcode load IML in a configuration, for     example an IBM z/CECSIM configuration, that parallels the post-IML     cosimulator environment. This is illustrated in block 101 of FIG. 1. -   2) When central electronic core simulator has reached a Post-IML     state. At this point create a “snapshot” of all micro-architected     facilities and associated data areas in memory. This is illustrated     in block 103 of FIG. 1. -   3) Superimpose the processor Post-IML state onto the post-IML     cosimulation hardware model. This may be done by using simulator API     commands, such as SimAPI commands. To update the model state, the     registers must be loaded into the model along with associated ecc     and parity. This is illustrated in block 105 of FIG. 1. -   4) Load the Hardware System Area (“HAS”) into Memory section of the     post-IML cosimulator model. This is illustrated in block 107 of FIG.     1.

Upon completion of these steps, as shown in FIG. 2, the post-IML cosimulation environment has been pre-loaded with the post IML characteristics from z/CECSIM. It actually starts where the z/CECSIM PSW left off “waiting for work”.

As shown in FIG. 2, the data in the central electronic core simulator 201, including millicode, microcode, and hardware system area 2011, and the hardware and high level models and macros 2013, are transferred 203 when the IML is complete, as determined by an IML Checkpoint that includes the Hardware System Area, millicode, code, and micro-architected hardware facilities. The is transferred to the PICOSIM (Post Initial Microcode Load Cosimulator) which includes the Central Electronic Core Hardware Model, with the Memory and Hardware System Area 2051 of the processor being modeled and the processor hardware facilities of the processor being modeled.

For verification purposes, the “work” referred to above is a s/390 testcase that is loaded into customer storage. In an IBM zSeries server, the function Restart PSW (Program Status Word) can be used to “boot” these programs. To execute this function in PICOSIM, it is necessary to insert a New PSW into customer storage at location zero and notify millicode that a Restart PSW is requested. When clocks are applied to the PICOSIM model, millicode retrieves the New PSW, and program execution begins at the new instruction address that points to the testcase.

The invention may be implemented, for example, by having the hardware simulator as a software application (as an operating system element), a dedicated processor, or a dedicated processor with dedicated code. The code executes a sequence of machine-readable instructions, which can also be referred to as code. These instructions may reside in various types of signal-bearing media. In this respect, one aspect of the present invention concerns a program product, comprising a signal-bearing medium or signal-bearing media tangibly embodying a program of machine-readable instructions executable by a digital processing apparatus to perform a method for hardware simulation.

This signal-bearing medium may comprise, for example, memory in a server. The memory in the server may be non-volatile storage, a data disc, or even memory on a vendor server for downloading to a processor for installation. Alternatively, the instructions may be embodied in a signal-bearing medium such as the optical data storage disc. Alternatively, the instructions may be stored on any of a variety of machine-readable data storage mediums or media, which may include, for example, a “hard drive”, a RAID array, a RAMAC, a magnetic data storage diskette (such as a floppy disk), magnetic tape, digital optical tape, RAM, ROM, EPROM, EEPROM, flash memory, magneto-optical storage, paper punch cards, or any other suitable signal-bearing media including transmission media such as digital and/or analog communications links, which may be electrical, optical, and/or wireless. As an example, the machine-readable instructions may comprise software object code, compiled from a language such as “C++”.

Additionally, the program code may, for example, be compressed, encrypted, or both, and may include executable files, script files and wizards for installation, as in Zip files and cab files. As used herein the term machine-readable instructions or code residing in or on signal-bearing media include all of the above means of delivery.

While the preferred embodiment to the invention has been described, it will be understood that those skilled in the art, both now and in the future, may make various improvements and enhancements which fall within the scope of the claims which follow. These claims should be construed to maintain the proper protection for the invention first described. 

1. A method of simulating a logic circuit comprising running a central electronic core simulator in a high level simulator up whereby to create a post-initial microcode load state, and thereafter transferring the post-initial microcode state from the central electonic core simulation to a post-initial microcode state from the central electronic core simulation to a post-initial microcode load co-simulator model to simulate the logic circuit comprising the steps of: running an initial microcode load in a first configuration in the high level simulator that parallels the post-initial microcode load state in a post-initial microcode cosimulator environment, wherein the initial microcode load initializes the simulated logic circuit and loads firmware to support code execution using the simulated logic circuit; creating a snapshot of the post-initial microcode load state in the high level simulator of all micro-architected facilities, a Hardware System Area, and associated data areas in memory in response to completing the initial microcode load; superimposing the processor post-initial microcode load state onto the post-initial microcode load cosimulation hardware model using simulator API commands, and loading the registers into the model along with associated error correcting code (ecc) and parity to update the model state to run on a co-simulator; and loading the Hardware System Area data into a memory section of the post-initial microcode load cosimulator model; inserting a new program status word (PSW) for a test case; asserting a notification that a restart is requested; retrieving the new PSW in response to applying a clock to the post-initial microcode load cosimulator model; and beginning post-initial microcode load cosimulator model execution on the co-simulator at an instruction address that points to the test case. 